"""
轻量级Markdown解析器
支持基础Markdown语法，专为MicroBlog设计
"""

import re
import html
from typing import Dict, List, Tuple


class MarkdownParser:
    """轻量级Markdown解析器"""
    
    def __init__(self):
        self.html_content = ""
        
    def parse(self, markdown_text: str) -> str:
        """
        将Markdown文本解析为HTML
        
        Args:
            markdown_text: 原始Markdown文本
            
        Returns:
            解析后的HTML字符串
        """
        if not markdown_text:
            return ""
            
        # 预处理：统一换行符
        text = markdown_text.replace('\r\n', '\n').replace('\r', '\n')
        
        # 按行分割
        lines = text.split('\n')
        
        # 解析各种元素
        html_lines = []
        i = 0
        in_code_block = False
        code_block_lang = ""
        code_block_lines = []
        
        while i < len(lines):
            line = lines[i]
            
            # 处理代码块
            if line.strip().startswith('```'):
                if not in_code_block:
                    # 开始代码块
                    in_code_block = True
                    code_block_lang = line.strip()[3:].strip()
                    code_block_lines = []
                else:
                    # 结束代码块
                    in_code_block = False
                    # 生成带复制按钮的代码块
                    code_content = '\n'.join(code_block_lines)
                    escaped_content = html.escape(code_content)
                    html_lines.append(f'<div class="code-block-container"><button class="code-copy-btn" onclick="copyCode(this, \'{code_block_lang}\')">复制</button><pre><code class="language-{code_block_lang}">{escaped_content}</code></pre></div>')
                    code_block_lines = []
                i += 1
                continue
                
            if in_code_block:
                # 在代码块内，保存原始行（用于复制功能）
                code_block_lines.append(line)
                i += 1
                continue
            
            # 处理标题
            if line.strip().startswith('#'):
                html_lines.append(self._parse_heading(line))
            # 处理引用
            elif line.strip().startswith('>'):
                blockquote_lines = []
                while i < len(lines) and lines[i].strip().startswith('>'):
                    blockquote_lines.append(lines[i].strip()[1:].strip())
                    i += 1
                html_lines.append(f'<blockquote><p>{" ".join(blockquote_lines)}</p></blockquote>')
                continue
            # 处理无序列表
            elif line.strip().startswith(('- ', '* ', '+ ')):
                list_items = []
                while i < len(lines) and lines[i].strip().startswith(('- ', '* ', '+ ')):
                    item_text = lines[i].strip()[2:]
                    list_items.append(f'<li>{self._parse_inline(item_text)}</li>')
                    i += 1
                html_lines.append(f'<ul>{"".join(list_items)}</ul>')
                continue
            # 处理有序列表
            elif re.match(r'^\d+\.\s', line.strip()):
                list_items = []
                while i < len(lines) and re.match(r'^\d+\.\s', lines[i].strip()):
                    item_text = re.sub(r'^\d+\.\s', '', lines[i].strip())
                    list_items.append(f'<li>{self._parse_inline(item_text)}</li>')
                    i += 1
                html_lines.append(f'<ol>{"".join(list_items)}</ol>')
                continue
            # 处理水平线
            elif line.strip() in ['---', '***', '___']:
                html_lines.append('<hr>')
            # 处理表格
            elif '|' in line and line.strip():
                table_lines = []
                while i < len(lines) and '|' in lines[i]:
                    table_lines.append(lines[i])
                    i += 1
                html_lines.append(self._parse_table(table_lines))
                continue
            # 处理空行
            elif not line.strip():
                html_lines.append('')
            # 处理普通段落
            else:
                # 收集连续的非空行作为段落
                paragraph_lines = []
                temp_i = i
                while temp_i < len(lines) and lines[temp_i].strip() and not self._is_special_line(lines[temp_i]):
                    paragraph_lines.append(lines[temp_i].strip())
                    temp_i += 1
                
                # 如果找到了完整的段落，就处理它
                if paragraph_lines:
                    paragraph_text = ' '.join(paragraph_lines)
                    html_lines.append(f'<p>{self._parse_inline(paragraph_text)}</p>')
                    i = temp_i
                    continue
                else:
                    # 如果没有段落内容，输出这一行
                    html_lines.append(f'<p>{self._parse_inline(line.strip())}</p>')
            
            i += 1
        
        return '\n'.join(html_lines)
    
    def _parse_heading(self, line: str) -> str:
        """解析标题"""
        line = line.strip()
        level = 0
        while level < len(line) and line[level] == '#':
            level += 1
        
        if level > 6:
            level = 6
            
        title_text = line[level:].strip()
        return f'<h{level}>{self._parse_inline(title_text)}</h{level}>'
    
    def _parse_inline(self, text: str) -> str:
        """解析行内元素"""
        # 先处理 &&LeTax&& 语法（避免被HTML转义）
        text = re.sub(r'&&LeTax&&', r'<span class="letax">&#8476;</span>', text)
        
        # 转义HTML
        text = html.escape(text)
        
        # 粗体 **text** 或 __text__
        text = re.sub(r'\*\*(.*?)\*\*', r'<strong>\1</strong>', text)
        text = re.sub(r'__(.*?)__', r'<strong>\1</strong>', text)
        
        # 斜体 *text* 或 _text_
        text = re.sub(r'\*(.*?)\*', r'<em>\1</em>', text)
        text = re.sub(r'_(.*?)_', r'<em>\1</em>', text)
        
        # 行内代码 `code` (需要在HTML转义后处理)
        text = re.sub(r'`(.*?)`', r'<code>\1</code>', text)
        
        # 删除线 ~~text~~
        text = re.sub(r'~~(.*?)~~', r'<del>\1</del>', text)
        
        # 链接 [text](url)
        text = re.sub(r'\[([^\]]+)\]\(([^)]+)\)', r'<a href="\2">\1</a>', text)
        
        # 图片 ![alt](url)
        text = re.sub(r'!\[([^\]]*)\]\(([^)]+)\)', r'<img src="\2" alt="\1">', text)
        
        return text
    
    def _parse_table(self, table_lines: List[str]) -> str:
        """解析表格"""
        if len(table_lines) < 2:
            return ""
            
        # 解析表头
        header_line = table_lines[0].strip()
        headers = [cell.strip() for cell in header_line.split('|') if cell.strip()]
        
        # 跳过分隔线
        data_lines = table_lines[2:] if len(table_lines) > 2 else []
        
        html = '<table><thead><tr>'
        for header in headers:
            html += f'<th>{self._parse_inline(header)}</th>'
        html += '</tr></thead><tbody>'
        
        for line in data_lines:
            cells = [cell.strip() for cell in line.split('|') if cell.strip()]
            html += '<tr>'
            for cell in cells:
                html += f'<td>{self._parse_inline(cell)}</td>'
            html += '</tr>'
        
        html += '</tbody></table>'
        return html
    
    def _is_special_line(self, line: str) -> bool:
        """检查是否为特殊行（标题、列表等）"""
        line = line.strip()
        return (
            line.startswith('#') or
            line.startswith('>') or
            line.startswith(('- ', '* ', '+ ')) or
            re.match(r'^\d+\.\s', line) or
            line in ['---', '***', '___'] or
            '|' in line or
            line.startswith('```')
        )


def parse_markdown(markdown_text: str) -> str:
    """
    便捷函数：解析Markdown文本为HTML
    
    Args:
        markdown_text: Markdown文本
        
    Returns:
        HTML字符串
    """
    parser = MarkdownParser()
    return parser.parse(markdown_text)


# 测试函数
def test_parser():
    """测试Markdown解析器"""
    test_md = """
# 这是标题1

## 这是标题2

这是一个普通段落，包含**粗体**和*斜体*文本，还有`行内代码`。

- 无序列表项1
- 无序列表项2
- 无序列表项3

1. 有序列表项1
2. 有序列表项2
3. 有序列表项3

> 这是一个引用块
> 可以包含多行内容

```python
def hello_world():
    print("Hello, World!")
```

[这是链接](https://example.com)

![这是图片](https://example.com/image.jpg)

| 表头1 | 表头2 | 表头3 |
|-------|-------|-------|
| 单元格1 | 单元格2 | 单元格3 |
| 单元格4 | 单元格5 | 单元格6 |

---

~~删除线文本~~
"""
    
    parser = MarkdownParser()
    html = parser.parse(test_md)
    print("Markdown解析测试:")
    print("=" * 50)
    print(html)
    print("=" * 50)


if __name__ == "__main__":
    test_parser()
